namespace ext
{
	using System;
	using System.Runtime.CompilerServices;
	using System.Html;
	using System.Collections;
	
	
	/// <definedin>src\core\Ext-more.js</definedin>
	/// <definedin>src\core\Ext-more.js</definedin>
	/// <definedin>src\core\Ext-more.js</definedin>
	/// <definedin>src\core\Ext-more.js</definedin>
	/// <definedin>src\core\Ext-more.js</definedin>
	/// <definedin>src\core\Ext-more.js</definedin>
	/// <definedin>src\ext-core\src\core\Ext.js</definedin>
	/// <definedin>src\ext-core\src\core\Ext.js</definedin>
	/// <definedin>src\ext-core\src\core\Ext.js</definedin>
	[ScriptName("Ext")]
	[IgnoreNamespace()]
	[Imported()]
	public sealed partial class Ext
	{
		
		#region Constructors
		/// <summary>Constructor</summary>
		private Ext()
		{
		}
		#endregion
		
		#region Properties
		/// <summary>Namespace alloted for extensions to the framework.</summary>
		/// <definedin>src\core\Ext-more.js</definedin>
		[ScriptName("ux")]
		[IntrinsicProperty()]
		public static object Ux
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>
		/// URL to a 1x1 transparent gif image used by Ext to create inline icons with CSS background images.
		/// In older versions of IE, this defaults to &quot;http://extjs.com/s.gif&quot; and you should change this to a URL on your server.
		/// For other browsers it uses an inline data URL.
		/// </summary>
		/// <definedin>src\core\Ext-more.js</definedin>
		[ScriptName("BLANK_IMAGE_URL")]
		[IntrinsicProperty()]
		public static string BLANK_IMAGE_URL
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
		}
		
		/// <summary>
		/// By default, Ext intelligently decides whether floating elements should be shimmed. If you are using flash,
		/// you may want to set this to true.
		/// </summary>
		/// <definedin>src\core\Ext-more.js</definedin>
		[ScriptName("useShims")]
		[IntrinsicProperty()]
		public static bool UseShims
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>The version of the framework</summary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		[ScriptName("version")]
		[IntrinsicProperty()]
		public static string Version
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>
		/// URL to a blank file used by Ext when in secure mode for iframe src and onReady src to prevent
		/// the IE insecure content warning (&apos;about:blank&apos;, except for IE in secure mode, which is &apos;javascript:&quot;&quot;&apos;).
		/// </summary>
		/// <htmlSummary>
		/// URL to a blank file used by Ext when in secure mode for iframe src and onReady src to prevent
		/// the IE insecure content warning (&lt;tt&gt;&apos;about:blank&apos;&lt;/tt&gt;, except for IE in secure mode, which is &lt;tt&gt;&apos;javascript:&quot;&quot;&apos;&lt;/tt&gt;).
		/// </htmlSummary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		[ScriptName("SSL_SECURE_URL")]
		[IntrinsicProperty()]
		public static string SSL_SECURE_URL
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
		}
		
		/// <summary>True if the browser is in strict (standards-compliant) mode, as opposed to quirks mode</summary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		[ScriptName("isStrict")]
		[IntrinsicProperty()]
		public static bool IsStrict
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>True if the page is running over SSL</summary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		[ScriptName("isSecure")]
		[IntrinsicProperty()]
		public static bool IsSecure
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>True when the document is fully initialized and ready for action</summary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		[ScriptName("isReady")]
		[IntrinsicProperty()]
		public static bool IsReady
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>True if the {@link Ext.Fx} Class is available</summary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		[ScriptName("enableFx")]
		[IntrinsicProperty()]
		public static bool EnableFx
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>
		/// HIGHLY EXPERIMENTAL
		/// True to force css based border-box model override and turning off javascript based adjustments. This is a
		/// runtime configuration and must be set before onReady.
		/// </summary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		[ScriptName("enableForcedBoxModel")]
		[IntrinsicProperty()]
		public static bool EnableForcedBoxModel
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>True to automatically uncache orphaned Ext.Elements periodically (defaults to true)</summary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		[ScriptName("enableGarbageCollector")]
		[IntrinsicProperty()]
		public static bool EnableGarbageCollector
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>True to automatically purge event listeners during garbageCollection (defaults to false).</summary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		[ScriptName("enableListenerCollection")]
		[IntrinsicProperty()]
		public static bool EnableListenerCollection
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>
		/// EXPERIMENTAL - True to cascade listener removal to child elements when an element is removed.
		/// Currently not optimized for performance.
		/// </summary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		[ScriptName("enableNestedListenerRemoval")]
		[IntrinsicProperty()]
		public static bool EnableNestedListenerRemoval
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>
		/// Indicates whether to use native browser parsing for JSON methods.
		/// This option is ignored if the browser does not support native JSON methods.
		/// Note: Native JSON methods will not work with objects that have functions.
		/// Also, property names must be quoted, otherwise the data will not parse. (Defaults to false)
		/// </summary>
		/// <htmlSummary>
		/// Indicates whether to use native browser parsing for JSON methods.
		/// This option is ignored if the browser does not support native JSON methods.
		/// &lt;b&gt;Note: Native JSON methods will not work with objects that have functions.
		/// Also, property names must be quoted, otherwise the data will not parse.&lt;/b&gt; (Defaults to false)
		/// </htmlSummary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		[ScriptName("USE_NATIVE_JSON")]
		[IntrinsicProperty()]
		public static bool USE_NATIVE_JSON
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
		}
		
		/// <summary>True if the detected browser is Opera.</summary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		[ScriptName("isOpera")]
		[IntrinsicProperty()]
		public static bool IsOpera
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>True if the detected browser uses WebKit.</summary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		[ScriptName("isWebKit")]
		[IntrinsicProperty()]
		public static bool IsWebKit
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>True if the detected browser is Chrome.</summary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		[ScriptName("isChrome")]
		[IntrinsicProperty()]
		public static bool IsChrome
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>True if the detected browser is Safari.</summary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		[ScriptName("isSafari")]
		[IntrinsicProperty()]
		public static bool IsSafari
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>True if the detected browser is Safari 3.x.</summary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		[ScriptName("isSafari3")]
		[IntrinsicProperty()]
		public static bool IsSafari3
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>True if the detected browser is Safari 4.x.</summary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		[ScriptName("isSafari4")]
		[IntrinsicProperty()]
		public static bool IsSafari4
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>True if the detected browser is Safari 2.x.</summary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		[ScriptName("isSafari2")]
		[IntrinsicProperty()]
		public static bool IsSafari2
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>True if the detected browser is Internet Explorer.</summary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		[ScriptName("isIE")]
		[IntrinsicProperty()]
		public static bool IsIE
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>True if the detected browser is Internet Explorer 6.x.</summary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		[ScriptName("isIE6")]
		[IntrinsicProperty()]
		public static bool IsIE6
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>True if the detected browser is Internet Explorer 7.x.</summary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		[ScriptName("isIE7")]
		[IntrinsicProperty()]
		public static bool IsIE7
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>True if the detected browser is Internet Explorer 8.x.</summary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		[ScriptName("isIE8")]
		[IntrinsicProperty()]
		public static bool IsIE8
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>True if the detected browser uses the Gecko layout engine (e.g. Mozilla, Firefox).</summary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		[ScriptName("isGecko")]
		[IntrinsicProperty()]
		public static bool IsGecko
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>True if the detected browser uses a pre-Gecko 1.9 layout engine (e.g. Firefox 2.x).</summary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		[ScriptName("isGecko2")]
		[IntrinsicProperty()]
		public static bool IsGecko2
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>True if the detected browser uses a Gecko 1.9+ layout engine (e.g. Firefox 3.x).</summary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		[ScriptName("isGecko3")]
		[IntrinsicProperty()]
		public static bool IsGecko3
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>True if the detected browser is Internet Explorer running in non-strict mode.</summary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		[ScriptName("isBorderBox")]
		[IntrinsicProperty()]
		public static bool IsBorderBox
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>True if the detected platform is Linux.</summary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		[ScriptName("isLinux")]
		[IntrinsicProperty()]
		public static bool IsLinux
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>True if the detected platform is Windows.</summary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		[ScriptName("isWindows")]
		[IntrinsicProperty()]
		public static bool IsWindows
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>True if the detected platform is Mac OS.</summary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		[ScriptName("isMac")]
		[IntrinsicProperty()]
		public static bool IsMac
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>True if the detected platform is Adobe Air.</summary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		[ScriptName("isAir")]
		[IntrinsicProperty()]
		public static bool IsAir
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		#endregion
		
		#region Methods
		/// <summary>Returns the current HTML document object as an {@link Ext.Element}.</summary>
		/// <definedin>src\core\Ext-more.js</definedin>
		/// <returns>The document</returns>
		[ScriptName("getDoc")]
		public static ext.Element GetDoc()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Utility method for validating that a value is numeric, returning the specified default value if it is not.</summary>
		/// <definedin>src\core\Ext-more.js</definedin>
		/// <param name="value">Should be a number, but any type will be handled appropriately</param>
		/// <param name="defaultValue">The value to return if the original value is non-numeric</param>
		/// <returns>Value, if numeric, else defaultValue</returns>
		[ScriptName("num")]
		public static System.Number Num(object value, System.Number defaultValue)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Escapes the passed string for use in a regular expression</summary>
		/// <definedin>src\core\Ext-more.js</definedin>
		/// <param name="str"></param>
		[ScriptName("escapeRe")]
		public static string EscapeRe(string str)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Applies event listeners to elements by selectors when the document is ready.
		/// The event name is specified with an @ suffix.
		/// 
		/// Ext.addBehaviors({
		/// // add a listener for click on all anchors in element with id foo
		/// &apos;#foo a@click&apos; : function(e, t){
		/// // do something
		/// },
		///
		/// // add the same listener to multiple selectors (separated by comma BEFORE the @)
		/// &apos;#foo a, #bar span.some-class@mouseover&apos; : function(){
		/// // do something
		/// }
		/// });
		/// </summary>
		/// <htmlSummary>
		/// Applies event listeners to elements by selectors when the document is ready.
		/// The event name is specified with an &lt;tt&gt;&amp;#64;&lt;/tt&gt; suffix.
		/// &lt;pre&gt;&lt;code&gt;
		/// Ext.addBehaviors({
		/// // add a listener for click on all anchors in element with id foo
		/// &apos;#foo a&amp;#64;click&apos; : function(e, t){
		/// // do something
		/// },
		///
		/// // add the same listener to multiple selectors (separated by comma BEFORE the &amp;#64;)
		/// &apos;#foo a, #bar span.some-class&amp;#64;mouseover&apos; : function(){
		/// // do something
		/// }
		/// });
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\core\Ext-more.js</definedin>
		/// <param name="obj">The list of behaviors to apply</param>
		[ScriptName("addBehaviors")]
		public static void AddBehaviors(object obj)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Creates a copy of the passed Array with falsy values removed.</summary>
		/// <definedin>src\core\Ext-more.js</definedin>
		/// <param name="arr">The Array from which to remove falsy values.</param>
		/// <returns>The new, compressed Array.</returns>
		[ScriptName("clean")]
		public static System.Array Clean(System.Array arr)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Creates a copy of the passed Array, filtered to contain only unique values.</summary>
		/// <definedin>src\core\Ext-more.js</definedin>
		/// <param name="arr">The Array to filter</param>
		/// <returns>The new Array containing unique values.</returns>
		[ScriptName("unique")]
		public static System.Array Unique(System.Array arr)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Recursively flattens into 1-d Array. Injects Arrays inline.</summary>
		/// <definedin>src\core\Ext-more.js</definedin>
		/// <param name="arr">The array to flatten</param>
		/// <returns>The new, flattened array.</returns>
		[ScriptName("flatten")]
		public static System.Array Flatten(System.Array arr)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Calculates the mean of the Array</summary>
		/// <definedin>src\core\Ext-more.js</definedin>
		/// <param name="arr">The Array to calculate the mean value of.</param>
		/// <returns>The mean.</returns>
		[ScriptName("mean")]
		public static System.Number Mean(System.Array arr)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Calculates the sum of the Array</summary>
		/// <definedin>src\core\Ext-more.js</definedin>
		/// <param name="arr">The Array to calculate the sum value of.</param>
		/// <returns>The sum.</returns>
		[ScriptName("sum")]
		public static System.Number Sum(System.Array arr)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Plucks the value of a property from each item in the Array
		/// 
		/// // Example:
		/// Ext.pluck(Ext.query(&quot;p&quot;), &quot;className&quot;); // [el1.className, el2.className, ..., elN.className]
		/// </summary>
		/// <htmlSummary>
		/// Plucks the value of a property from each item in the Array
		/// &lt;pre&gt;&lt;code&gt;
		/// // Example:
		/// Ext.pluck(Ext.query(&quot;p&quot;), &quot;className&quot;); // [el1.className, el2.className, ..., elN.className]
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\core\Ext-more.js</definedin>
		/// <param name="arr">The Array of items to pluck the value from.</param>
		/// <param name="prop">The property name to pluck from each element.</param>
		/// <returns>The value from each item in the Array.</returns>
		[ScriptName("pluck")]
		public static System.Array Pluck(System.Array arr, string prop)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// This is shorthand reference to {@link Ext.ComponentMgr#get}.
		/// Looks up an existing {@link Ext.Component Component} by {@link Ext.Component#id id}
		/// </summary>
		/// <definedin>src\core\Ext-more.js</definedin>
		/// <param name="id">The component {@link Ext.Component#id id}</param>
		/// <returns>
		/// The Component, &lt;tt&gt;undefined&lt;/tt&gt; if not found, or &lt;tt&gt;null&lt;/tt&gt; if a
		/// Class was found.
		/// </returns>
		[ScriptName("getCmp")]
		public static ext.Component GetCmp(string id)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Returns the type of object that is passed in. If the object passed in is null or undefined it
		/// return false otherwise it returns one of the following values:   string: If the object passed is a string  number: If the object passed is a number  boolean: If the object passed is a boolean value  date: If the object passed is a Date object  function: If the object passed is a function reference  object: If the object passed is an object  array: If the object passed is an array  regexp: If the object passed is a regular expression  element: If the object passed is a DOM Element  nodelist: If the object passed is a DOM NodeList  textnode: If the object passed is a DOM text node and contains something other than whitespace  whitespace: If the object passed is a DOM text node and contains only whitespace
		/// </summary>
		/// <htmlSummary>
		/// Returns the type of object that is passed in. If the object passed in is null or undefined it
		/// return false otherwise it returns one of the following values:&lt;div class=&quot;mdetail-params&quot;&gt;&lt;ul&gt;
		/// &lt;li&gt;&lt;b&gt;string&lt;/b&gt;: If the object passed is a string&lt;/li&gt;
		/// &lt;li&gt;&lt;b&gt;number&lt;/b&gt;: If the object passed is a number&lt;/li&gt;
		/// &lt;li&gt;&lt;b&gt;boolean&lt;/b&gt;: If the object passed is a boolean value&lt;/li&gt;
		/// &lt;li&gt;&lt;b&gt;date&lt;/b&gt;: If the object passed is a Date object&lt;/li&gt;
		/// &lt;li&gt;&lt;b&gt;function&lt;/b&gt;: If the object passed is a function reference&lt;/li&gt;
		/// &lt;li&gt;&lt;b&gt;object&lt;/b&gt;: If the object passed is an object&lt;/li&gt;
		/// &lt;li&gt;&lt;b&gt;array&lt;/b&gt;: If the object passed is an array&lt;/li&gt;
		/// &lt;li&gt;&lt;b&gt;regexp&lt;/b&gt;: If the object passed is a regular expression&lt;/li&gt;
		/// &lt;li&gt;&lt;b&gt;element&lt;/b&gt;: If the object passed is a DOM Element&lt;/li&gt;
		/// &lt;li&gt;&lt;b&gt;nodelist&lt;/b&gt;: If the object passed is a DOM NodeList&lt;/li&gt;
		/// &lt;li&gt;&lt;b&gt;textnode&lt;/b&gt;: If the object passed is a DOM text node and contains something other than whitespace&lt;/li&gt;
		/// &lt;li&gt;&lt;b&gt;whitespace&lt;/b&gt;: If the object passed is a DOM text node and contains only whitespace&lt;/li&gt;
		/// &lt;/ul&gt;&lt;/div&gt;
		/// </htmlSummary>
		/// <definedin>src\core\Ext-more.js</definedin>
		/// <param name="object"></param>
		[ScriptName("type")]
		public static string Type(object @object)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Retrieves Ext.Element objects.
		/// This method does not retrieve {@link Ext.Component Component}s. This method
		/// retrieves Ext.Element objects which encapsulate DOM elements. To retrieve a Component by
		/// its ID, use {@link Ext.ComponentMgr#get}.  Uses simple caching to consistently return the same object. Automatically fixes if an
		/// object was recreated with the same id via AJAX or DOM. 
		/// Shorthand of {@link Ext.Element#get}
		/// </summary>
		/// <htmlSummary>
		/// Retrieves Ext.Element objects.
		/// &lt;p&gt;&lt;b&gt;This method does not retrieve {@link Ext.Component Component}s.&lt;/b&gt; This method
		/// retrieves Ext.Element objects which encapsulate DOM elements. To retrieve a Component by
		/// its ID, use {@link Ext.ComponentMgr#get}.&lt;/p&gt;
		/// &lt;p&gt;Uses simple caching to consistently return the same object. Automatically fixes if an
		/// object was recreated with the same id via AJAX or DOM.&lt;/p&gt;
		/// Shorthand of {@link Ext.Element#get}
		/// </htmlSummary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		/// <param name="el">The id of the node, a DOM Node or an existing Element.</param>
		/// <returns>The Element object (or null if no matching element was found)</returns>
		[ScriptName("get")]
		public static ext.Element Get(object el)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Copies all the properties of config to obj.</summary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		/// <param name="obj">The receiver of the properties</param>
		/// <param name="config">The source of the properties</param>
		/// <param name="defaults">A different object that will also be applied for default values</param>
		/// <returns>returns obj</returns>
		[ScriptName("apply")]
		public static object Apply(object obj, object config, object defaults)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Copies all the properties of config to obj if they don&apos;t already exist.</summary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		/// <param name="obj">The receiver of the properties</param>
		/// <param name="config">The source of the properties</param>
		/// <returns>returns obj</returns>
		[ScriptName("applyIf")]
		public static object ApplyIf(object obj, object config)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Extends one class to create a subclass and optionally overrides members with the passed literal. This method
		/// also adds the function &quot;override()&quot; to the subclass that can be used to override members of the class. 
		/// For example, to create a subclass of Ext GridPanel:
		/// 
		/// MyGridPanel = Ext.extend(Ext.grid.GridPanel, {
		/// constructor: function(config) {
		///
		/// // Create configuration for this Grid.
		/// var store = new Ext.data.Store({...});
		/// var colModel = new Ext.grid.ColumnModel({...});
		///
		/// // Create a new config object containing our computed properties
		/// // *plus* whatever was in the config parameter.
		/// config = Ext.apply({
		/// store: store,
		/// colModel: colModel
		/// }, config);
		///
		/// MyGridPanel.superclass.constructor.call(this, config);
		///
		/// // Your postprocessing here
		/// },
		///
		/// yourMethod: function() {
		/// // etc.
		/// }
		/// });
		///  This function also supports a 3-argument call in which the subclass&apos;s constructor is
		/// passed as an argument. In this form, the parameters are as follows:    subclass : Function  The...
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Extends one class to create a subclass and optionally overrides members with the passed literal. This method
		/// also adds the function &quot;override()&quot; to the subclass that can be used to override members of the class.&lt;/p&gt;
		/// For example, to create a subclass of Ext GridPanel:
		/// &lt;pre&gt;&lt;code&gt;
		/// MyGridPanel = Ext.extend(Ext.grid.GridPanel, {
		/// constructor: function(config) {
		///
		/// // Create configuration for this Grid.
		/// var store = new Ext.data.Store({...});
		/// var colModel = new Ext.grid.ColumnModel({...});
		///
		/// // Create a new config object containing our computed properties
		/// // *plus* whatever was in the config parameter.
		/// config = Ext.apply({
		/// store: store,
		/// colModel: colModel
		/// }, config);
		///
		/// MyGridPanel.superclass.constructor.call(this, config);
		///
		/// // Your postprocessing here
		/// },
		///
		/// yourMethod: function() {
		/// // etc.
		/// }
		/// });
		/// &lt;/code&gt;&lt;/pre&gt;
		///
		/// &lt;p&gt;This function also supports a 3-argument call in which the subclass&apos;s constructor is
		/// passed as an argument. In this form, the parameters are as follows:&lt;/p&gt;
		/// &lt;div class=&quot;mdetail-params&quot;&gt;&lt;ul&gt;
		/// &lt;li&gt;&lt;code&gt;subclass&lt;/code&gt; : Function &lt;div class=&quot;sub-desc&quot;&gt;The subclass constructor.&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;code&gt;superclass&lt;/code&gt; : Function &lt;div class=&quot;sub-desc&quot;&gt;The constructor of class being extended&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;code&gt;overrides&lt;/code&gt; : Object &lt;div class=&quot;sub-desc&quot;&gt;A literal with members which are copied into the subclass&apos;s
		/// prototype, and are therefore shared among all instances of the new class.&lt;/div&gt;&lt;/li&gt;
		/// &lt;/ul&gt;&lt;/div&gt;
		/// </htmlSummary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		/// <param name="superclass">The constructor of class being extended.</param>
		/// <param name="overrides">
		/// &lt;p&gt;A literal with members which are copied into the subclass&apos;s
		/// prototype, and are therefore shared between all instances of the new class.&lt;/p&gt;
		/// &lt;p&gt;This may contain a special member named &lt;tt&gt;&lt;b&gt;constructor&lt;/b&gt;&lt;/tt&gt;. This is used
		/// to define the constructor of the new class, and is returned. If this property is
		/// &lt;i&gt;not&lt;/i&gt; specified, a constructor is generated and returned which just calls the
		/// superclass&apos;s constructor passing on its parameters.&lt;/p&gt;
		/// &lt;p&gt;&lt;b&gt;It is essential that you call the superclass constructor in any provided constructor. See example code.&lt;/b&gt;&lt;/p&gt;
		/// </param>
		/// <returns>The subclass constructor from the <c>overrides</c> parameter, or a generated one if not provided.</returns>
		[ScriptName("extend")]
		public static System.Function Extend(System.Delegate superclass, object overrides)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Adds a list of functions to the prototype of an existing class, overwriting any existing methods with the same name.
		/// Usage: 
		/// Ext.override(MyClass, {
		/// newMethod1: function(){
		/// // etc.
		/// },
		/// newMethod2: function(foo){
		/// // etc.
		/// }
		/// });
		/// </summary>
		/// <htmlSummary>
		/// Adds a list of functions to the prototype of an existing class, overwriting any existing methods with the same name.
		/// Usage:&lt;pre&gt;&lt;code&gt;
		/// Ext.override(MyClass, {
		/// newMethod1: function(){
		/// // etc.
		/// },
		/// newMethod2: function(foo){
		/// // etc.
		/// }
		/// });
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		/// <param name="origclass">The class to override</param>
		/// <param name="overrides">
		/// The list of functions to add to origClass. This should be specified as an object literal
		/// containing one or more methods.
		/// </param>
		[ScriptName("override")]
		public static void Override(object origclass, object overrides)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Appends content to the query string of a URL, handling logic for whether to place
		/// a question mark or ampersand.
		/// </summary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		/// <param name="url">The URL to append to.</param>
		/// <param name="s">The content to append to the URL.</param>
		/// <returns>The resulting URL</returns>
		[ScriptName("urlAppend")]
		public static string UrlAppend(string url, string s)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Converts any iterable (numeric indices and a length property) into a true array
		/// Don&apos;t use this on strings. IE doesn&apos;t support &quot;abc&quot;[0] which this implementation depends on.
		/// For strings, use this instead: &quot;abc&quot;.match(/./g) =&gt; [a,b,c];
		/// </summary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		/// <param name="the">iterable object to be turned into a true Array.</param>
		/// <returns>array</returns>
		[ScriptName("toArray")]
		public static System.Array ToArray(System.Collections.IEnumerable the)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Return the dom node for the passed String (id), dom node, or Ext.Element.
		/// Optional &apos;strict&apos; flag is needed for IE since it can return &apos;name&apos; and
		/// &apos;id&apos; elements by using getElementById.
		/// Here are some examples:
		/// 
		/// // gets dom node based on id
		/// var elDom = Ext.getDom(&apos;elId&apos;);
		/// // gets dom node based on the dom node
		/// var elDom1 = Ext.getDom(elDom);
		///
		/// // If we don&apos;t know if we are working with an
		/// // Ext.Element or a dom node use Ext.getDom
		/// function(el){
		/// var dom = Ext.getDom(el);
		/// // do something with the dom node
		/// }
		/// Note: the dom node to be found actually needs to exist (be rendered, etc)
		/// when this method is called to be successful.
		/// </summary>
		/// <htmlSummary>
		/// Return the dom node for the passed String (id), dom node, or Ext.Element.
		/// Optional &apos;strict&apos; flag is needed for IE since it can return &apos;name&apos; and
		/// &apos;id&apos; elements by using getElementById.
		/// Here are some examples:
		/// &lt;pre&gt;&lt;code&gt;
		/// // gets dom node based on id
		/// var elDom = Ext.getDom(&apos;elId&apos;);
		/// // gets dom node based on the dom node
		/// var elDom1 = Ext.getDom(elDom);
		///
		/// // If we don&amp;#39;t know if we are working with an
		/// // Ext.Element or a dom node use Ext.getDom
		/// function(el){
		/// var dom = Ext.getDom(el);
		/// // do something with the dom node
		/// }
		/// &lt;/code&gt;&lt;/pre&gt;
		/// &lt;b&gt;Note&lt;/b&gt;: the dom node to be found actually needs to exist (be rendered, etc)
		/// when this method is called to be successful.
		/// </htmlSummary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		/// <param name="el"></param>
		[ScriptName("getDom")]
		public static System.Html.Element GetDom(object el)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Returns the current document body as an {@link Ext.Element}.</summary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		/// <returns>The document body</returns>
		[ScriptName("getBody")]
		public static ext.Element GetBody()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Returns the current document body as an {@link Ext.Element}.</summary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		/// <returns>The document body</returns>
		[ScriptName("getHead")]
		public static ext.Element GetHead()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Removes this element from the document, removes all DOM event listeners, and deletes the cache reference.
		/// All DOM event listeners are removed from this element. If {@link Ext#enableNestedListenerRemoval} is
		/// true, then DOM event listeners are also removed from all child nodes. The body node
		/// will be ignored if passed in.
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Removes this element from the document, removes all DOM event listeners, and deletes the cache reference.
		/// All DOM event listeners are removed from this element. If {@link Ext#enableNestedListenerRemoval} is
		/// &lt;code&gt;true&lt;/code&gt;, then DOM event listeners are also removed from all child nodes. The body node
		/// will be ignored if passed in.&lt;/p&gt;
		/// </htmlSummary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		/// <param name="node">The node to remove</param>
		[ScriptName("removeNode")]
		public static void RemoveNode(System.Html.Element node)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Returns true if the passed value is a JavaScript array, otherwise false.</summary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		/// <param name="value">The value to test</param>
		[ScriptName("isArray")]
		public static bool IsArray(object value)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Returns true if the passed object is a JavaScript date object, otherwise false.</summary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		/// <param name="object">The object to test</param>
		[ScriptName("isDate")]
		public static bool IsDate(object @object)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Returns true if the passed value is a JavaScript Object, otherwise false.</summary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		/// <param name="value">The value to test</param>
		[ScriptName("isObject")]
		public static bool IsObject(object value)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Returns true if the passed value is a JavaScript &apos;primitive&apos;, a string, number or boolean.</summary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		/// <param name="value">The value to test</param>
		[ScriptName("isPrimitive")]
		public static bool IsPrimitive(object value)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Returns true if the passed value is a JavaScript Function, otherwise false.</summary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		/// <param name="value">The value to test</param>
		[ScriptName("isFunction")]
		public static bool IsFunction(object value)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Returns true if the passed value is a number. Returns false for non-finite numbers.</summary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		/// <param name="value">The value to test</param>
		[ScriptName("isNumber")]
		public static bool IsNumber(object value)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Returns true if the passed value is a string.</summary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		/// <param name="value">The value to test</param>
		[ScriptName("isString")]
		public static bool IsString(object value)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Returns true if the passed value is a boolean.</summary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		/// <param name="value">The value to test</param>
		[ScriptName("isBoolean")]
		public static bool IsBoolean(object value)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Returns true if the passed value is an HTMLElement</summary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		/// <param name="value">The value to test</param>
		[ScriptName("isElement")]
		public static bool IsElement(object value)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Returns true if the passed value is not undefined.</summary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		/// <param name="value">The value to test</param>
		[ScriptName("isDefined")]
		public static bool IsDefined(object value)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Shorthand for {@link Ext.util.JSON#encode}</summary>
		/// <definedin>src\ext-core\src\util\JSON.js</definedin>
		/// <param name="o">The variable to encode</param>
		/// <returns>The JSON string</returns>
		[ScriptName("encode")]
		public static string Encode(object o)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Shorthand for {@link Ext.ComponentMgr#registerType}</summary>
		/// <definedin>src\widgets\ComponentMgr.js</definedin>
		/// <param name="xtype">
		/// The {@link Ext.component#xtype mnemonic string} by which the Component class
		/// may be looked up.
		/// </param>
		/// <param name="cls">The new Component class.</param>
		[ScriptName("reg")]
		public static void Reg(string xtype, System.Type cls)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Shorthand for {@link Ext.ComponentMgr#registerPlugin}</summary>
		/// <definedin>src\widgets\ComponentMgr.js</definedin>
		/// <param name="ptype">
		/// The {@link Ext.component#ptype mnemonic string} by which the Plugin class
		/// may be looked up.
		/// </param>
		/// <param name="cls">The new Plugin class.</param>
		[ScriptName("preg")]
		public static void Preg(string ptype, System.Type cls)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Shorthand for {@link Ext.ComponentMgr#create}
		/// Creates a new Component from the specified config object using the
		/// config object&apos;s {@link Ext.component#xtype xtype} to determine the class to instantiate.
		/// </summary>
		/// <definedin>src\widgets\ComponentMgr.js</definedin>
		/// <param name="config">A configuration object for the Component you wish to create.</param>
		/// <param name="defaultType">
		/// The constructor to provide the default Component type if
		/// the config object does not contain a <c>xtype</c>. (Optional if the config contains a <c>xtype</c>).
		/// </param>
		/// <returns>The newly instantiated Component.</returns>
		[ScriptName("create")]
		public static ext.Component Create(object config, System.Type defaultType)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Selects elements based on the passed CSS selector to enable {@link Ext.Element Element} methods
		/// to be applied to many related elements in one statement through the returned {@link Ext.CompositeElement CompositeElement} or
		/// {@link Ext.CompositeElementLite CompositeElementLite} object.
		/// </summary>
		/// <definedin>src\core\CompositeElement.js</definedin>
		/// <param name="selector">The CSS selector or an array of elements</param>
		/// <param name="unique">true to create a unique Ext.Element for each element (defaults to a shared flyweight object)</param>
		/// <param name="root">The root element of the query or id of the root</param>
		[ScriptName("select")]
		public static ext.auto.ext_CompositeElementLite_Or_ext_CompositeElement Select(string selector, bool unique, System.Html.Element root)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Selects elements based on the passed CSS selector to enable {@link Ext.Element Element} methods
		/// to be applied to many related elements in one statement through the returned {@link Ext.CompositeElement CompositeElement} or
		/// {@link Ext.CompositeElementLite CompositeElementLite} object.
		/// </summary>
		/// <definedin>src\core\CompositeElement.js</definedin>
		/// <param name="selector">The CSS selector or an array of elements</param>
		/// <param name="unique">true to create a unique Ext.Element for each element (defaults to a shared flyweight object)</param>
		/// <param name="root">The root element of the query or id of the root</param>
		[ScriptName("select")]
		public static ext.auto.ext_CompositeElementLite_Or_ext_CompositeElement Select(string selector, bool unique, string root)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Selects elements based on the passed CSS selector to enable {@link Ext.Element Element} methods
		/// to be applied to many related elements in one statement through the returned {@link Ext.CompositeElement CompositeElement} or
		/// {@link Ext.CompositeElementLite CompositeElementLite} object.
		/// </summary>
		/// <definedin>src\core\CompositeElement.js</definedin>
		/// <param name="selector">The CSS selector or an array of elements</param>
		/// <param name="unique">true to create a unique Ext.Element for each element (defaults to a shared flyweight object)</param>
		/// <param name="root">The root element of the query or id of the root</param>
		[ScriptName("select")]
		public static ext.auto.ext_CompositeElementLite_Or_ext_CompositeElement Select(System.Array selector, bool unique, System.Html.Element root)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Selects elements based on the passed CSS selector to enable {@link Ext.Element Element} methods
		/// to be applied to many related elements in one statement through the returned {@link Ext.CompositeElement CompositeElement} or
		/// {@link Ext.CompositeElementLite CompositeElementLite} object.
		/// </summary>
		/// <definedin>src\core\CompositeElement.js</definedin>
		/// <param name="selector">The CSS selector or an array of elements</param>
		/// <param name="unique">true to create a unique Ext.Element for each element (defaults to a shared flyweight object)</param>
		/// <param name="root">The root element of the query or id of the root</param>
		[ScriptName("select")]
		public static ext.auto.ext_CompositeElementLite_Or_ext_CompositeElement Select(System.Array selector, bool unique, string root)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Selects elements based on the passed CSS selector to enable {@link Ext.Element Element} methods
		/// to be applied to many related elements in one statement through the returned {@link Ext.CompositeElement CompositeElement} or
		/// {@link Ext.CompositeElementLite CompositeElementLite} object.
		/// </summary>
		/// <definedin>src\core\CompositeElement.js</definedin>
		/// <param name="selector">The CSS selector or an array of elements</param>
		/// <param name="unique">true to create a unique Ext.Element for each element (defaults to a shared flyweight object)</param>
		[ScriptName("select")]
		public static ext.auto.ext_CompositeElementLite_Or_ext_CompositeElement Select(string selector, bool unique)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Selects elements based on the passed CSS selector to enable {@link Ext.Element Element} methods
		/// to be applied to many related elements in one statement through the returned {@link Ext.CompositeElement CompositeElement} or
		/// {@link Ext.CompositeElementLite CompositeElementLite} object.
		/// </summary>
		/// <definedin>src\core\CompositeElement.js</definedin>
		/// <param name="selector">The CSS selector or an array of elements</param>
		/// <param name="unique">true to create a unique Ext.Element for each element (defaults to a shared flyweight object)</param>
		[ScriptName("select")]
		public static ext.auto.ext_CompositeElementLite_Or_ext_CompositeElement Select(System.Array selector, bool unique)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Framework-wide error-handler. Developers can override this method to provide
		/// custom exception-handling. Framework errors will often extend from the base
		/// Ext.Error class.
		/// </summary>
		/// <definedin>src\core\Error.js</definedin>
		/// <param name="e">The thrown exception object.</param>
		[ScriptName("handleError")]
		public static void HandleError(object e)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Framework-wide error-handler. Developers can override this method to provide
		/// custom exception-handling. Framework errors will often extend from the base
		/// Ext.Error class.
		/// </summary>
		/// <definedin>src\core\Error.js</definedin>
		/// <param name="e">The thrown exception object.</param>
		[ScriptName("handleError")]
		public static void HandleError(ext.Error e)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Utility method for returning a default value if the passed value is empty.  The value is deemed to be empty if it is   null  undefined  an empty array  a zero length string (Unless the allowBlank parameter is true)</summary>
		/// <htmlSummary>
		/// &lt;p&gt;Utility method for returning a default value if the passed value is empty.&lt;/p&gt;
		/// &lt;p&gt;The value is deemed to be empty if it is&lt;div class=&quot;mdetail-params&quot;&gt;&lt;ul&gt;
		/// &lt;li&gt;null&lt;/li&gt;
		/// &lt;li&gt;undefined&lt;/li&gt;
		/// &lt;li&gt;an empty array&lt;/li&gt;
		/// &lt;li&gt;a zero length string (Unless the &lt;tt&gt;allowBlank&lt;/tt&gt; parameter is &lt;tt&gt;true&lt;/tt&gt;)&lt;/li&gt;
		/// &lt;/ul&gt;&lt;/div&gt;
		/// </htmlSummary>
		/// <definedin>src\core\Ext-more.js</definedin>
		/// <param name="value">The value to test</param>
		/// <param name="defaultValue">The value to return if the original value is empty</param>
		/// <param name="allowBlank">true to allow zero length strings to qualify as non-empty (defaults to false)</param>
		/// <returns>value, if non-empty, else defaultValue</returns>
		[ScriptName("value")]
		public static object Value(object value, object defaultValue, bool allowBlank)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Utility method for returning a default value if the passed value is empty.  The value is deemed to be empty if it is   null  undefined  an empty array  a zero length string (Unless the allowBlank parameter is true)</summary>
		/// <htmlSummary>
		/// &lt;p&gt;Utility method for returning a default value if the passed value is empty.&lt;/p&gt;
		/// &lt;p&gt;The value is deemed to be empty if it is&lt;div class=&quot;mdetail-params&quot;&gt;&lt;ul&gt;
		/// &lt;li&gt;null&lt;/li&gt;
		/// &lt;li&gt;undefined&lt;/li&gt;
		/// &lt;li&gt;an empty array&lt;/li&gt;
		/// &lt;li&gt;a zero length string (Unless the &lt;tt&gt;allowBlank&lt;/tt&gt; parameter is &lt;tt&gt;true&lt;/tt&gt;)&lt;/li&gt;
		/// &lt;/ul&gt;&lt;/div&gt;
		/// </htmlSummary>
		/// <definedin>src\core\Ext-more.js</definedin>
		/// <param name="value">The value to test</param>
		/// <param name="defaultValue">The value to return if the original value is empty</param>
		/// <returns>value, if non-empty, else defaultValue</returns>
		[ScriptName("value")]
		public static object Value(object value, object defaultValue)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Utility method for getting the width of the browser scrollbar. This can differ depending on
		/// operating system settings, such as the theme or font size.
		/// </summary>
		/// <definedin>src\core\Ext-more.js</definedin>
		/// <param name="force">true to force a recalculation of the value.</param>
		/// <returns>The width of the scrollbar.</returns>
		[ScriptName("getScrollBarWidth")]
		public static System.Number GetScrollBarWidth(bool force)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Utility method for getting the width of the browser scrollbar. This can differ depending on
		/// operating system settings, such as the theme or font size.
		/// </summary>
		/// <definedin>src\core\Ext-more.js</definedin>
		/// <returns>The width of the scrollbar.</returns>
		[ScriptName("getScrollBarWidth")]
		public static System.Number GetScrollBarWidth()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Copies a set of named properties fom the source object to the destination object.
		/// example: 
		/// ImageComponent = Ext.extend(Ext.BoxComponent, {
		/// initComponent: function() {
		/// this.autoEl = { tag: &apos;img&apos; };
		/// MyComponent.superclass.initComponent.apply(this, arguments);
		/// this.initialBox = Ext.copyTo({}, this.initialConfig, &apos;x,y,width,height&apos;);
		/// }
		/// });
		/// </summary>
		/// <htmlSummary>
		/// Copies a set of named properties fom the source object to the destination object.
		/// &lt;p&gt;example:&lt;pre&gt;&lt;code&gt;
		/// ImageComponent = Ext.extend(Ext.BoxComponent, {
		/// initComponent: function() {
		/// this.autoEl = { tag: &apos;img&apos; };
		/// MyComponent.superclass.initComponent.apply(this, arguments);
		/// this.initialBox = Ext.copyTo({}, this.initialConfig, &apos;x,y,width,height&apos;);
		/// }
		/// });
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\core\Ext-more.js</definedin>
		/// <param name="dest">The destination object.</param>
		/// <param name="source">The source object.</param>
		/// <param name="names">
		/// Either an Array of property names, or a comma-delimited list
		/// of property names to copy.
		/// </param>
		/// <returns>The modified object.</returns>
		[ScriptName("copyTo")]
		public static object CopyTo(object dest, object source, System.Array names)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Copies a set of named properties fom the source object to the destination object.
		/// example: 
		/// ImageComponent = Ext.extend(Ext.BoxComponent, {
		/// initComponent: function() {
		/// this.autoEl = { tag: &apos;img&apos; };
		/// MyComponent.superclass.initComponent.apply(this, arguments);
		/// this.initialBox = Ext.copyTo({}, this.initialConfig, &apos;x,y,width,height&apos;);
		/// }
		/// });
		/// </summary>
		/// <htmlSummary>
		/// Copies a set of named properties fom the source object to the destination object.
		/// &lt;p&gt;example:&lt;pre&gt;&lt;code&gt;
		/// ImageComponent = Ext.extend(Ext.BoxComponent, {
		/// initComponent: function() {
		/// this.autoEl = { tag: &apos;img&apos; };
		/// MyComponent.superclass.initComponent.apply(this, arguments);
		/// this.initialBox = Ext.copyTo({}, this.initialConfig, &apos;x,y,width,height&apos;);
		/// }
		/// });
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\core\Ext-more.js</definedin>
		/// <param name="dest">The destination object.</param>
		/// <param name="source">The source object.</param>
		/// <param name="names">
		/// Either an Array of property names, or a comma-delimited list
		/// of property names to copy.
		/// </param>
		/// <returns>The modified object.</returns>
		[ScriptName("copyTo")]
		public static object CopyTo(object dest, object source, string names)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Attempts to destroy any objects passed to it by removing all event listeners, removing them from the
		/// DOM (if applicable) and calling their destroy functions (if available). This method is primarily
		/// intended for arguments of type {@link Ext.Element} and {@link Ext.Component}, but any subclass of
		/// {@link Ext.util.Observable} can be passed in. Any number of elements and/or components can be
		/// passed into this function in a single call as separate arguments.
		/// </summary>
		/// <definedin>src\core\Ext-more.js</definedin>
		/// <param name="args">An {@link Ext.Element}, {@link Ext.Component}, or an Array of either of these to destroy</param>
		[ScriptName("destroy")]
		public static void Destroy(params object[] args)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Attempts to destroy any objects passed to it by removing all event listeners, removing them from the
		/// DOM (if applicable) and calling their destroy functions (if available). This method is primarily
		/// intended for arguments of type {@link Ext.Element} and {@link Ext.Component}, but any subclass of
		/// {@link Ext.util.Observable} can be passed in. Any number of elements and/or components can be
		/// passed into this function in a single call as separate arguments.
		/// </summary>
		/// <definedin>src\core\Ext-more.js</definedin>
		[ScriptName("destroy")]
		public static void Destroy()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Attempts to destroy and then remove a set of named properties of the passed object.</summary>
		/// <definedin>src\core\Ext-more.js</definedin>
		/// <param name="o">The object (most likely a Component) who&apos;s properties you wish to destroy.</param>
		/// <param name="args">The name of the property to destroy and remove from the object.</param>
		[ScriptName("destroyMembers")]
		public static void DestroyMembers(object o, params object[] args)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Attempts to destroy and then remove a set of named properties of the passed object.</summary>
		/// <definedin>src\core\Ext-more.js</definedin>
		/// <param name="o">The object (most likely a Component) who&apos;s properties you wish to destroy.</param>
		[ScriptName("destroyMembers")]
		public static void DestroyMembers(object o)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Returns the minimum value in the Array.</summary>
		/// <definedin>src\core\Ext-more.js</definedin>
		/// <param name="arr">The Array from which to select the minimum value.</param>
		/// <param name="comp">
		/// a function to perform the comparision which determines minimization.
		/// If omitted the &quot;&lt;&quot; operator will be used. Note: gt = 1; eq = 0; lt = -1
		/// </param>
		/// <returns>The minimum value in the Array.</returns>
		[ScriptName("min")]
		public static object Min(System.Array arr, System.Delegate comp)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Returns the minimum value in the Array.</summary>
		/// <definedin>src\core\Ext-more.js</definedin>
		/// <param name="arr">The Array from which to select the minimum value.</param>
		/// <returns>The minimum value in the Array.</returns>
		[ScriptName("min")]
		public static object Min(System.Array arr)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Returns the maximum value in the Array</summary>
		/// <definedin>src\core\Ext-more.js</definedin>
		/// <param name="arr">The Array from which to select the maximum value.</param>
		/// <param name="comp">
		/// a function to perform the comparision which determines maximization.
		/// If omitted the &quot;&gt;&quot; operator will be used. Note: gt = 1; eq = 0; lt = -1
		/// </param>
		/// <returns>The maximum value in the Array.</returns>
		[ScriptName("max")]
		public static object Max(System.Array arr, System.Delegate comp)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Returns the maximum value in the Array</summary>
		/// <definedin>src\core\Ext-more.js</definedin>
		/// <param name="arr">The Array from which to select the maximum value.</param>
		/// <returns>The maximum value in the Array.</returns>
		[ScriptName("max")]
		public static object Max(System.Array arr)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Partitions the set into two sets: a true set and a false set.
		/// Example:
		/// Example2:
		/// 
		/// // Example 1:
		/// Ext.partition([true, false, true, true, false]); // [[true, true, true], [false, false]]
		///
		/// // Example 2:
		/// Ext.partition(
		/// Ext.query(&quot;p&quot;),
		/// function(val){
		/// return val.className == &quot;class1&quot;
		/// }
		/// );
		/// // true are those paragraph elements with a className of &quot;class1&quot;,
		/// // false set are those that do not have that className.
		/// </summary>
		/// <htmlSummary>
		/// Partitions the set into two sets: a true set and a false set.
		/// Example:
		/// Example2:
		/// &lt;pre&gt;&lt;code&gt;
		/// // Example 1:
		/// Ext.partition([true, false, true, true, false]); // [[true, true, true], [false, false]]
		///
		/// // Example 2:
		/// Ext.partition(
		/// Ext.query(&quot;p&quot;),
		/// function(val){
		/// return val.className == &quot;class1&quot;
		/// }
		/// );
		/// // true are those paragraph elements with a className of &quot;class1&quot;,
		/// // false set are those that do not have that className.
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\core\Ext-more.js</definedin>
		/// <param name="arr">The array to partition</param>
		/// <param name="truth">
		/// a function to determine truth. If this is omitted the element
		/// itself must be able to be evaluated for its truthfulness.
		/// </param>
		/// <returns>[true&lt;Array&gt;,false&lt;Array&gt;]</returns>
		[ScriptName("partition")]
		public static System.Array Partition(System.Array arr, System.Delegate truth)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Partitions the set into two sets: a true set and a false set.
		/// Example:
		/// Example2:
		/// 
		/// // Example 1:
		/// Ext.partition([true, false, true, true, false]); // [[true, true, true], [false, false]]
		///
		/// // Example 2:
		/// Ext.partition(
		/// Ext.query(&quot;p&quot;),
		/// function(val){
		/// return val.className == &quot;class1&quot;
		/// }
		/// );
		/// // true are those paragraph elements with a className of &quot;class1&quot;,
		/// // false set are those that do not have that className.
		/// </summary>
		/// <htmlSummary>
		/// Partitions the set into two sets: a true set and a false set.
		/// Example:
		/// Example2:
		/// &lt;pre&gt;&lt;code&gt;
		/// // Example 1:
		/// Ext.partition([true, false, true, true, false]); // [[true, true, true], [false, false]]
		///
		/// // Example 2:
		/// Ext.partition(
		/// Ext.query(&quot;p&quot;),
		/// function(val){
		/// return val.className == &quot;class1&quot;
		/// }
		/// );
		/// // true are those paragraph elements with a className of &quot;class1&quot;,
		/// // false set are those that do not have that className.
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\core\Ext-more.js</definedin>
		/// <param name="arr">The array to partition</param>
		/// <returns>[true&lt;Array&gt;,false&lt;Array&gt;]</returns>
		[ScriptName("partition")]
		public static System.Array Partition(System.Array arr)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Invokes a method on each item in an Array.
		/// 
		/// // Example:
		/// Ext.invoke(Ext.query(&quot;p&quot;), &quot;getAttribute&quot;, &quot;id&quot;);
		/// // [el1.getAttribute(&quot;id&quot;), el2.getAttribute(&quot;id&quot;), ..., elN.getAttribute(&quot;id&quot;)]
		/// </summary>
		/// <htmlSummary>
		/// Invokes a method on each item in an Array.
		/// &lt;pre&gt;&lt;code&gt;
		/// // Example:
		/// Ext.invoke(Ext.query(&quot;p&quot;), &quot;getAttribute&quot;, &quot;id&quot;);
		/// // [el1.getAttribute(&quot;id&quot;), el2.getAttribute(&quot;id&quot;), ..., elN.getAttribute(&quot;id&quot;)]
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\core\Ext-more.js</definedin>
		/// <param name="arr">The Array of items to invoke the method on.</param>
		/// <param name="methodName">The method name to invoke.</param>
		/// <param name="args">Variable length parameter array - Arguments to send into the method invocation.</param>
		/// <returns>The results of invoking the method on each item in the array.</returns>
		[ScriptName("invoke")]
		public static System.Array Invoke(System.Array arr, string methodName, params object[] args)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Invokes a method on each item in an Array.
		/// 
		/// // Example:
		/// Ext.invoke(Ext.query(&quot;p&quot;), &quot;getAttribute&quot;, &quot;id&quot;);
		/// // [el1.getAttribute(&quot;id&quot;), el2.getAttribute(&quot;id&quot;), ..., elN.getAttribute(&quot;id&quot;)]
		/// </summary>
		/// <htmlSummary>
		/// Invokes a method on each item in an Array.
		/// &lt;pre&gt;&lt;code&gt;
		/// // Example:
		/// Ext.invoke(Ext.query(&quot;p&quot;), &quot;getAttribute&quot;, &quot;id&quot;);
		/// // [el1.getAttribute(&quot;id&quot;), el2.getAttribute(&quot;id&quot;), ..., elN.getAttribute(&quot;id&quot;)]
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\core\Ext-more.js</definedin>
		/// <param name="arr">The Array of items to invoke the method on.</param>
		/// <param name="methodName">The method name to invoke.</param>
		/// <returns>The results of invoking the method on each item in the array.</returns>
		[ScriptName("invoke")]
		public static System.Array Invoke(System.Array arr, string methodName)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Zips N sets together.  
		/// // Example 1:
		/// Ext.zip([1,2,3],[4,5,6]); // [[1,4],[2,5],[3,6]]
		/// // Example 2:
		/// Ext.zip(
		/// [ &quot;+&quot;, &quot;-&quot;, &quot;+&quot;],
		/// [ 12, 10, 22],
		/// [ 43, 15, 96],
		/// function(a, b, c){
		/// return &quot;$&quot; + a + &quot;&quot; + b + &quot;.&quot; + c
		/// }
		/// ); // [&quot;$+12.43&quot;, &quot;$-10.15&quot;, &quot;$+22.96&quot;]
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Zips N sets together.&lt;/p&gt;
		/// &lt;pre&gt;&lt;code&gt;
		/// // Example 1:
		/// Ext.zip([1,2,3],[4,5,6]); // [[1,4],[2,5],[3,6]]
		/// // Example 2:
		/// Ext.zip(
		/// [ &quot;+&quot;, &quot;-&quot;, &quot;+&quot;],
		/// [ 12, 10, 22],
		/// [ 43, 15, 96],
		/// function(a, b, c){
		/// return &quot;$&quot; + a + &quot;&quot; + b + &quot;.&quot; + c
		/// }
		/// ); // [&quot;$+12.43&quot;, &quot;$-10.15&quot;, &quot;$+22.96&quot;]
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\core\Ext-more.js</definedin>
		/// <param name="arr">This argument may be repeated. Array(s) to contribute values.</param>
		/// <param name="zipper">The last item in the argument list. This will drive how the items are zipped together.</param>
		/// <returns>The zipped set.</returns>
		[ScriptName("zip")]
		public static System.Array Zip(System.Array[] arr, System.Delegate zipper)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Zips N sets together.  
		/// // Example 1:
		/// Ext.zip([1,2,3],[4,5,6]); // [[1,4],[2,5],[3,6]]
		/// // Example 2:
		/// Ext.zip(
		/// [ &quot;+&quot;, &quot;-&quot;, &quot;+&quot;],
		/// [ 12, 10, 22],
		/// [ 43, 15, 96],
		/// function(a, b, c){
		/// return &quot;$&quot; + a + &quot;&quot; + b + &quot;.&quot; + c
		/// }
		/// ); // [&quot;$+12.43&quot;, &quot;$-10.15&quot;, &quot;$+22.96&quot;]
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Zips N sets together.&lt;/p&gt;
		/// &lt;pre&gt;&lt;code&gt;
		/// // Example 1:
		/// Ext.zip([1,2,3],[4,5,6]); // [[1,4],[2,5],[3,6]]
		/// // Example 2:
		/// Ext.zip(
		/// [ &quot;+&quot;, &quot;-&quot;, &quot;+&quot;],
		/// [ 12, 10, 22],
		/// [ 43, 15, 96],
		/// function(a, b, c){
		/// return &quot;$&quot; + a + &quot;&quot; + b + &quot;.&quot; + c
		/// }
		/// ); // [&quot;$+12.43&quot;, &quot;$-10.15&quot;, &quot;$+22.96&quot;]
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\core\Ext-more.js</definedin>
		/// <param name="arr">This argument may be repeated. Array(s) to contribute values.</param>
		/// <returns>The zipped set.</returns>
		[ScriptName("zip")]
		public static System.Array Zip(System.Array[] arr)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Selects elements based on the passed CSS selector to enable {@link Ext.Element Element} methods
		/// to be applied to many related elements in one statement through the returned {@link Ext.CompositeElement CompositeElement} or
		/// {@link Ext.CompositeElementLite CompositeElementLite} object.
		/// </summary>
		/// <definedin>src\ext-core\src\core\CompositeElementLite.js</definedin>
		/// <param name="selector">The CSS selector or an array of elements</param>
		/// <param name="root">The root element of the query or id of the root</param>
		[ScriptName("select")]
		public static ext.auto.ext_CompositeElementLite_Or_ext_CompositeElement Select(string selector, System.Html.Element root)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Selects elements based on the passed CSS selector to enable {@link Ext.Element Element} methods
		/// to be applied to many related elements in one statement through the returned {@link Ext.CompositeElement CompositeElement} or
		/// {@link Ext.CompositeElementLite CompositeElementLite} object.
		/// </summary>
		/// <definedin>src\ext-core\src\core\CompositeElementLite.js</definedin>
		/// <param name="selector">The CSS selector or an array of elements</param>
		/// <param name="root">The root element of the query or id of the root</param>
		[ScriptName("select")]
		public static ext.auto.ext_CompositeElementLite_Or_ext_CompositeElement Select(string selector, string root)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Selects elements based on the passed CSS selector to enable {@link Ext.Element Element} methods
		/// to be applied to many related elements in one statement through the returned {@link Ext.CompositeElement CompositeElement} or
		/// {@link Ext.CompositeElementLite CompositeElementLite} object.
		/// </summary>
		/// <definedin>src\ext-core\src\core\CompositeElementLite.js</definedin>
		/// <param name="selector">The CSS selector or an array of elements</param>
		/// <param name="root">The root element of the query or id of the root</param>
		[ScriptName("select")]
		public static ext.auto.ext_CompositeElementLite_Or_ext_CompositeElement Select(System.Array selector, System.Html.Element root)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Selects elements based on the passed CSS selector to enable {@link Ext.Element Element} methods
		/// to be applied to many related elements in one statement through the returned {@link Ext.CompositeElement CompositeElement} or
		/// {@link Ext.CompositeElementLite CompositeElementLite} object.
		/// </summary>
		/// <definedin>src\ext-core\src\core\CompositeElementLite.js</definedin>
		/// <param name="selector">The CSS selector or an array of elements</param>
		/// <param name="root">The root element of the query or id of the root</param>
		[ScriptName("select")]
		public static ext.auto.ext_CompositeElementLite_Or_ext_CompositeElement Select(System.Array selector, string root)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Selects an array of DOM nodes by CSS/XPath selector. Shorthand of {@link Ext.DomQuery#select}</summary>
		/// <definedin>src\ext-core\src\core\DomQuery.js</definedin>
		/// <param name="path">The selector/xpath query</param>
		/// <param name="root">The start of the query (defaults to document).</param>
		[ScriptName("query")]
		public static System.Array Query(string path, object root)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Selects an array of DOM nodes by CSS/XPath selector. Shorthand of {@link Ext.DomQuery#select}</summary>
		/// <definedin>src\ext-core\src\core\DomQuery.js</definedin>
		/// <param name="path">The selector/xpath query</param>
		[ScriptName("query")]
		public static System.Array Query(string path)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Gets the globally shared flyweight Element, with the passed node as the active element. Do not store a reference to this element -
		/// the dom node can be overwritten by other code. Shorthand of {@link Ext.Element#fly}  Use this to make one-time references to DOM elements which are not going to be accessed again either by
		/// application code, or by Ext&apos;s classes. If accessing an element which will be processed regularly, then {@link Ext#get}
		/// will be more appropriate to take advantage of the caching provided by the Ext.Element class.
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Gets the globally shared flyweight Element, with the passed node as the active element. Do not store a reference to this element -
		/// the dom node can be overwritten by other code. Shorthand of {@link Ext.Element#fly}&lt;/p&gt;
		/// &lt;p&gt;Use this to make one-time references to DOM elements which are not going to be accessed again either by
		/// application code, or by Ext&apos;s classes. If accessing an element which will be processed regularly, then {@link Ext#get}
		/// will be more appropriate to take advantage of the caching provided by the Ext.Element class.&lt;/p&gt;
		/// </htmlSummary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		/// <param name="el">The dom node or id</param>
		/// <param name="named">
		/// Allows for creation of named reusable flyweights to prevent conflicts
		/// (e.g. internally Ext uses &quot;_global&quot;)
		/// </param>
		/// <returns>The shared Element object (or null if no matching element was found)</returns>
		[ScriptName("fly")]
		public static ext.Element Fly(string el, string named)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Gets the globally shared flyweight Element, with the passed node as the active element. Do not store a reference to this element -
		/// the dom node can be overwritten by other code. Shorthand of {@link Ext.Element#fly}  Use this to make one-time references to DOM elements which are not going to be accessed again either by
		/// application code, or by Ext&apos;s classes. If accessing an element which will be processed regularly, then {@link Ext#get}
		/// will be more appropriate to take advantage of the caching provided by the Ext.Element class.
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Gets the globally shared flyweight Element, with the passed node as the active element. Do not store a reference to this element -
		/// the dom node can be overwritten by other code. Shorthand of {@link Ext.Element#fly}&lt;/p&gt;
		/// &lt;p&gt;Use this to make one-time references to DOM elements which are not going to be accessed again either by
		/// application code, or by Ext&apos;s classes. If accessing an element which will be processed regularly, then {@link Ext#get}
		/// will be more appropriate to take advantage of the caching provided by the Ext.Element class.&lt;/p&gt;
		/// </htmlSummary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		/// <param name="el">The dom node or id</param>
		/// <param name="named">
		/// Allows for creation of named reusable flyweights to prevent conflicts
		/// (e.g. internally Ext uses &quot;_global&quot;)
		/// </param>
		/// <returns>The shared Element object (or null if no matching element was found)</returns>
		[ScriptName("fly")]
		public static ext.Element Fly(System.Html.Element el, string named)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Gets the globally shared flyweight Element, with the passed node as the active element. Do not store a reference to this element -
		/// the dom node can be overwritten by other code. Shorthand of {@link Ext.Element#fly}  Use this to make one-time references to DOM elements which are not going to be accessed again either by
		/// application code, or by Ext&apos;s classes. If accessing an element which will be processed regularly, then {@link Ext#get}
		/// will be more appropriate to take advantage of the caching provided by the Ext.Element class.
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Gets the globally shared flyweight Element, with the passed node as the active element. Do not store a reference to this element -
		/// the dom node can be overwritten by other code. Shorthand of {@link Ext.Element#fly}&lt;/p&gt;
		/// &lt;p&gt;Use this to make one-time references to DOM elements which are not going to be accessed again either by
		/// application code, or by Ext&apos;s classes. If accessing an element which will be processed regularly, then {@link Ext#get}
		/// will be more appropriate to take advantage of the caching provided by the Ext.Element class.&lt;/p&gt;
		/// </htmlSummary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		/// <param name="el">The dom node or id</param>
		/// <returns>The shared Element object (or null if no matching element was found)</returns>
		[ScriptName("fly")]
		public static ext.Element Fly(string el)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Gets the globally shared flyweight Element, with the passed node as the active element. Do not store a reference to this element -
		/// the dom node can be overwritten by other code. Shorthand of {@link Ext.Element#fly}  Use this to make one-time references to DOM elements which are not going to be accessed again either by
		/// application code, or by Ext&apos;s classes. If accessing an element which will be processed regularly, then {@link Ext#get}
		/// will be more appropriate to take advantage of the caching provided by the Ext.Element class.
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Gets the globally shared flyweight Element, with the passed node as the active element. Do not store a reference to this element -
		/// the dom node can be overwritten by other code. Shorthand of {@link Ext.Element#fly}&lt;/p&gt;
		/// &lt;p&gt;Use this to make one-time references to DOM elements which are not going to be accessed again either by
		/// application code, or by Ext&apos;s classes. If accessing an element which will be processed regularly, then {@link Ext#get}
		/// will be more appropriate to take advantage of the caching provided by the Ext.Element class.&lt;/p&gt;
		/// </htmlSummary>
		/// <definedin>src\ext-core\src\core\Element.js</definedin>
		/// <param name="el">The dom node or id</param>
		/// <returns>The shared Element object (or null if no matching element was found)</returns>
		[ScriptName("fly")]
		public static ext.Element Fly(System.Html.Element el)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Adds a listener to be notified when the document is ready (before onload and before images are loaded). Shorthand of {@link Ext.EventManager#onDocumentReady}.</summary>
		/// <definedin>src\ext-core\src\core\EventManager.js</definedin>
		/// <param name="fn">The method the event invokes.</param>
		/// <param name="scope">The scope (<c>this</c> reference) in which the handler function executes. Defaults to the browser window.</param>
		/// <param name="options">
		/// Options object as passed to {@link Ext.Element#addListener}. It is recommended that the options
		/// <c>{single: true}</c> be used so that the handler is removed on first invocation.
		/// </param>
		[ScriptName("onReady")]
		public static void OnReady(System.Delegate fn, object scope, bool options)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Adds a listener to be notified when the document is ready (before onload and before images are loaded). Shorthand of {@link Ext.EventManager#onDocumentReady}.</summary>
		/// <definedin>src\ext-core\src\core\EventManager.js</definedin>
		/// <param name="fn">The method the event invokes.</param>
		/// <param name="scope">The scope (<c>this</c> reference) in which the handler function executes. Defaults to the browser window.</param>
		[ScriptName("onReady")]
		public static void OnReady(System.Delegate fn, object scope)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Adds a listener to be notified when the document is ready (before onload and before images are loaded). Shorthand of {@link Ext.EventManager#onDocumentReady}.</summary>
		/// <definedin>src\ext-core\src\core\EventManager.js</definedin>
		/// <param name="fn">The method the event invokes.</param>
		[ScriptName("onReady")]
		public static void OnReady(System.Delegate fn)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Generates unique ids. If the element already has an id, it is unchanged</summary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		/// <param name="el">The element to generate an id for</param>
		/// <param name="prefix">Id prefix (defaults &quot;ext-gen&quot;)</param>
		/// <returns>The generated Id.</returns>
		[ScriptName("id")]
		public static string Id(object el, string prefix)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Generates unique ids. If the element already has an id, it is unchanged</summary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		/// <param name="el">The element to generate an id for</param>
		/// <returns>The generated Id.</returns>
		[ScriptName("id")]
		public static string Id(object el)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Generates unique ids. If the element already has an id, it is unchanged</summary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		/// <returns>The generated Id.</returns>
		[ScriptName("id")]
		public static string Id()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Creates namespaces to be used for scoping variables and classes so that they are not global.
		/// Specifying the last node of a namespace implicitly creates all other nodes. Usage:
		/// 
		/// Ext.namespace(&apos;Company&apos;, &apos;Company.data&apos;);
		/// Ext.namespace(&apos;Company.data&apos;); // equivalent and preferable to above syntax
		/// Company.Widget = function() { ... }
		/// Company.data.CustomStore = function(config) { ... }
		/// </summary>
		/// <htmlSummary>
		/// Creates namespaces to be used for scoping variables and classes so that they are not global.
		/// Specifying the last node of a namespace implicitly creates all other nodes. Usage:
		/// &lt;pre&gt;&lt;code&gt;
		/// Ext.namespace(&apos;Company&apos;, &apos;Company.data&apos;);
		/// Ext.namespace(&apos;Company.data&apos;); // equivalent and preferable to above syntax
		/// Company.Widget = function() { ... }
		/// Company.data.CustomStore = function(config) { ... }
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		/// <param name="namespaces"></param>
		/// <returns>The namespace object. (If multiple arguments are passed, this will be the last namespace created)</returns>
		[ScriptName("namespace")]
		public static object Namespace(params string[] namespaces)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Creates namespaces to be used for scoping variables and classes so that they are not global.
		/// Specifying the last node of a namespace implicitly creates all other nodes. Usage:
		/// 
		/// Ext.namespace(&apos;Company&apos;, &apos;Company.data&apos;);
		/// Ext.namespace(&apos;Company.data&apos;); // equivalent and preferable to above syntax
		/// Company.Widget = function() { ... }
		/// Company.data.CustomStore = function(config) { ... }
		/// </summary>
		/// <htmlSummary>
		/// Creates namespaces to be used for scoping variables and classes so that they are not global.
		/// Specifying the last node of a namespace implicitly creates all other nodes. Usage:
		/// &lt;pre&gt;&lt;code&gt;
		/// Ext.namespace(&apos;Company&apos;, &apos;Company.data&apos;);
		/// Ext.namespace(&apos;Company.data&apos;); // equivalent and preferable to above syntax
		/// Company.Widget = function() { ... }
		/// Company.data.CustomStore = function(config) { ... }
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		/// <returns>The namespace object. (If multiple arguments are passed, this will be the last namespace created)</returns>
		[ScriptName("namespace")]
		public static object Namespace()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Takes an object and converts it to an encoded URL. e.g. Ext.urlEncode({foo: 1, bar: 2}); would return &quot;foo=1&amp;bar=2&quot;. Optionally, property values can be arrays, instead of keys and the resulting string that&apos;s returned will contain a name/value pair for each array value.</summary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		/// <param name="o"></param>
		/// <param name="pre">A prefix to add to the url encoded string</param>
		[ScriptName("urlEncode")]
		public static string UrlEncode(object o, string pre)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Takes an object and converts it to an encoded URL. e.g. Ext.urlEncode({foo: 1, bar: 2}); would return &quot;foo=1&amp;bar=2&quot;. Optionally, property values can be arrays, instead of keys and the resulting string that&apos;s returned will contain a name/value pair for each array value.</summary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		/// <param name="o"></param>
		[ScriptName("urlEncode")]
		public static string UrlEncode(object o)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Takes an encoded URL and and converts it to an object. Example:  
		/// Ext.urlDecode(&quot;foo=1&amp;bar=2&quot;); // returns {foo: &quot;1&quot;, bar: &quot;2&quot;}
		/// Ext.urlDecode(&quot;foo=1&amp;bar=2&amp;bar=3&amp;bar=4&quot;, false); // returns {foo: &quot;1&quot;, bar: [&quot;2&quot;, &quot;3&quot;, &quot;4&quot;]}
		/// </summary>
		/// <htmlSummary>
		/// Takes an encoded URL and and converts it to an object. Example: &lt;pre&gt;&lt;code&gt;
		/// Ext.urlDecode(&quot;foo=1&amp;bar=2&quot;); // returns {foo: &quot;1&quot;, bar: &quot;2&quot;}
		/// Ext.urlDecode(&quot;foo=1&amp;bar=2&amp;bar=3&amp;bar=4&quot;, false); // returns {foo: &quot;1&quot;, bar: [&quot;2&quot;, &quot;3&quot;, &quot;4&quot;]}
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		/// <param name="string"></param>
		/// <param name="overwrite">Items of the same name will overwrite previous values instead of creating an an array (Defaults to false).</param>
		/// <returns>A literal with members</returns>
		[ScriptName("urlDecode")]
		public static object UrlDecode(string @string, bool overwrite)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Takes an encoded URL and and converts it to an object. Example:  
		/// Ext.urlDecode(&quot;foo=1&amp;bar=2&quot;); // returns {foo: &quot;1&quot;, bar: &quot;2&quot;}
		/// Ext.urlDecode(&quot;foo=1&amp;bar=2&amp;bar=3&amp;bar=4&quot;, false); // returns {foo: &quot;1&quot;, bar: [&quot;2&quot;, &quot;3&quot;, &quot;4&quot;]}
		/// </summary>
		/// <htmlSummary>
		/// Takes an encoded URL and and converts it to an object. Example: &lt;pre&gt;&lt;code&gt;
		/// Ext.urlDecode(&quot;foo=1&amp;bar=2&quot;); // returns {foo: &quot;1&quot;, bar: &quot;2&quot;}
		/// Ext.urlDecode(&quot;foo=1&amp;bar=2&amp;bar=3&amp;bar=4&quot;, false); // returns {foo: &quot;1&quot;, bar: [&quot;2&quot;, &quot;3&quot;, &quot;4&quot;]}
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		/// <param name="string"></param>
		/// <returns>A literal with members</returns>
		[ScriptName("urlDecode")]
		public static object UrlDecode(string @string)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Iterates an array calling the supplied function.</summary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		/// <param name="array">
		/// The array to be iterated. If this
		/// argument is not really an array, the supplied function is called once.
		/// </param>
		/// <param name="fn">
		/// The function to be called with each item. If the
		/// supplied function returns false, iteration stops and this method returns
		/// the current <c>index</c>. This function is called with
		/// the following arguments:
		/// &lt;div class=&quot;mdetail-params&quot;&gt;&lt;ul&gt;
		/// &lt;li&gt;<c>item</c> : &lt;i&gt;Mixed&lt;/i&gt;
		/// &lt;div class=&quot;sub-desc&quot;&gt;The item at the current <c>index</c>
		/// in the passed <c>array</c>&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;<c>index</c> : &lt;i&gt;Number&lt;/i&gt;
		/// &lt;div class=&quot;sub-desc&quot;&gt;The current index within the array&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;<c>allItems</c> : &lt;i&gt;Array&lt;/i&gt;
		/// &lt;div class=&quot;sub-desc&quot;&gt;The <c>array</c> passed as the first
		/// argument to <c>Ext.each</c>.&lt;/div&gt;&lt;/li&gt;
		/// &lt;/ul&gt;&lt;/div&gt;
		/// </param>
		/// <param name="scope">
		/// The scope (<c>this</c> reference) in which the specified function is executed.
		/// Defaults to the <c>item</c> at the current <c>index</c>
		/// within the passed <c>array</c>.
		/// </param>
		/// <returns>description for the fn parameter.</returns>
		[ScriptName("each")]
		public static int Each(System.Array array, System.Delegate fn, object scope)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Iterates an array calling the supplied function.</summary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		/// <param name="array">
		/// The array to be iterated. If this
		/// argument is not really an array, the supplied function is called once.
		/// </param>
		/// <param name="fn">
		/// The function to be called with each item. If the
		/// supplied function returns false, iteration stops and this method returns
		/// the current <c>index</c>. This function is called with
		/// the following arguments:
		/// &lt;div class=&quot;mdetail-params&quot;&gt;&lt;ul&gt;
		/// &lt;li&gt;<c>item</c> : &lt;i&gt;Mixed&lt;/i&gt;
		/// &lt;div class=&quot;sub-desc&quot;&gt;The item at the current <c>index</c>
		/// in the passed <c>array</c>&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;<c>index</c> : &lt;i&gt;Number&lt;/i&gt;
		/// &lt;div class=&quot;sub-desc&quot;&gt;The current index within the array&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;<c>allItems</c> : &lt;i&gt;Array&lt;/i&gt;
		/// &lt;div class=&quot;sub-desc&quot;&gt;The <c>array</c> passed as the first
		/// argument to <c>Ext.each</c>.&lt;/div&gt;&lt;/li&gt;
		/// &lt;/ul&gt;&lt;/div&gt;
		/// </param>
		/// <param name="scope">
		/// The scope (<c>this</c> reference) in which the specified function is executed.
		/// Defaults to the <c>item</c> at the current <c>index</c>
		/// within the passed <c>array</c>.
		/// </param>
		/// <returns>description for the fn parameter.</returns>
		[ScriptName("each")]
		public static int Each(object array, System.Delegate fn, object scope)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Iterates either the elements in an array, or each of the properties in an object.
		/// Note: If you are only iterating arrays, it is better to call {@link #each}.
		/// </summary>
		/// <htmlSummary>
		/// Iterates either the elements in an array, or each of the properties in an object.
		/// &lt;b&gt;Note&lt;/b&gt;: If you are only iterating arrays, it is better to call {@link #each}.
		/// </htmlSummary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		/// <param name="object">The object or array to be iterated</param>
		/// <param name="fn">
		/// The function to be called for each iteration.
		/// The iteration will stop if the supplied function returns false, or
		/// all array elements / object properties have been covered. The signature
		/// varies depending on the type of object being interated:
		/// &lt;div class=&quot;mdetail-params&quot;&gt;&lt;ul&gt;
		/// &lt;li&gt;Arrays : &lt;tt&gt;(Object item, Number index, Array allItems)&lt;/tt&gt;
		/// &lt;div class=&quot;sub-desc&quot;&gt;
		/// When iterating an array, the supplied function is called with each item.&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;Objects : &lt;tt&gt;(String key, Object value, Object)&lt;/tt&gt;
		/// &lt;div class=&quot;sub-desc&quot;&gt;
		/// When iterating an object, the supplied function is called with each key-value pair in
		/// the object, and the iterated object&lt;/div&gt;&lt;/li&gt;
		/// &lt;/ul&gt;&lt;/div&gt;
		/// </param>
		/// <param name="scope">
		/// The scope (<c>this</c> reference) in which the specified function is executed. Defaults to
		/// the <c>object</c> being iterated.
		/// </param>
		[ScriptName("iterate")]
		public static void Iterate(object @object, System.Delegate fn, object scope)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Iterates either the elements in an array, or each of the properties in an object.
		/// Note: If you are only iterating arrays, it is better to call {@link #each}.
		/// </summary>
		/// <htmlSummary>
		/// Iterates either the elements in an array, or each of the properties in an object.
		/// &lt;b&gt;Note&lt;/b&gt;: If you are only iterating arrays, it is better to call {@link #each}.
		/// </htmlSummary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		/// <param name="object">The object or array to be iterated</param>
		/// <param name="fn">
		/// The function to be called for each iteration.
		/// The iteration will stop if the supplied function returns false, or
		/// all array elements / object properties have been covered. The signature
		/// varies depending on the type of object being interated:
		/// &lt;div class=&quot;mdetail-params&quot;&gt;&lt;ul&gt;
		/// &lt;li&gt;Arrays : &lt;tt&gt;(Object item, Number index, Array allItems)&lt;/tt&gt;
		/// &lt;div class=&quot;sub-desc&quot;&gt;
		/// When iterating an array, the supplied function is called with each item.&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;Objects : &lt;tt&gt;(String key, Object value, Object)&lt;/tt&gt;
		/// &lt;div class=&quot;sub-desc&quot;&gt;
		/// When iterating an object, the supplied function is called with each key-value pair in
		/// the object, and the iterated object&lt;/div&gt;&lt;/li&gt;
		/// &lt;/ul&gt;&lt;/div&gt;
		/// </param>
		/// <param name="scope">
		/// The scope (<c>this</c> reference) in which the specified function is executed. Defaults to
		/// the <c>object</c> being iterated.
		/// </param>
		[ScriptName("iterate")]
		public static void Iterate(System.Array @object, System.Delegate fn, object scope)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Returns true if the passed value is empty.  The value is deemed to be empty if it is   null  undefined  an empty array  a zero length string (Unless the allowBlank parameter is true)</summary>
		/// <htmlSummary>
		/// &lt;p&gt;Returns true if the passed value is empty.&lt;/p&gt;
		/// &lt;p&gt;The value is deemed to be empty if it is&lt;div class=&quot;mdetail-params&quot;&gt;&lt;ul&gt;
		/// &lt;li&gt;null&lt;/li&gt;
		/// &lt;li&gt;undefined&lt;/li&gt;
		/// &lt;li&gt;an empty array&lt;/li&gt;
		/// &lt;li&gt;a zero length string (Unless the &lt;tt&gt;allowBlank&lt;/tt&gt; parameter is &lt;tt&gt;true&lt;/tt&gt;)&lt;/li&gt;
		/// &lt;/ul&gt;&lt;/div&gt;
		/// </htmlSummary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		/// <param name="value">The value to test</param>
		/// <param name="allowBlank">true to allow empty strings (defaults to false)</param>
		[ScriptName("isEmpty")]
		public static bool IsEmpty(object value, bool allowBlank)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Returns true if the passed value is empty.  The value is deemed to be empty if it is   null  undefined  an empty array  a zero length string (Unless the allowBlank parameter is true)</summary>
		/// <htmlSummary>
		/// &lt;p&gt;Returns true if the passed value is empty.&lt;/p&gt;
		/// &lt;p&gt;The value is deemed to be empty if it is&lt;div class=&quot;mdetail-params&quot;&gt;&lt;ul&gt;
		/// &lt;li&gt;null&lt;/li&gt;
		/// &lt;li&gt;undefined&lt;/li&gt;
		/// &lt;li&gt;an empty array&lt;/li&gt;
		/// &lt;li&gt;a zero length string (Unless the &lt;tt&gt;allowBlank&lt;/tt&gt; parameter is &lt;tt&gt;true&lt;/tt&gt;)&lt;/li&gt;
		/// &lt;/ul&gt;&lt;/div&gt;
		/// </htmlSummary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		/// <param name="value">The value to test</param>
		[ScriptName("isEmpty")]
		public static bool IsEmpty(object value)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Creates namespaces to be used for scoping variables and classes so that they are not global.
		/// Specifying the last node of a namespace implicitly creates all other nodes. Usage:
		/// 
		/// Ext.namespace(&apos;Company&apos;, &apos;Company.data&apos;);
		/// Ext.namespace(&apos;Company.data&apos;); // equivalent and preferable to above syntax
		/// Company.Widget = function() { ... }
		/// Company.data.CustomStore = function(config) { ... }
		/// </summary>
		/// <htmlSummary>
		/// Creates namespaces to be used for scoping variables and classes so that they are not global.
		/// Specifying the last node of a namespace implicitly creates all other nodes. Usage:
		/// &lt;pre&gt;&lt;code&gt;
		/// Ext.namespace(&apos;Company&apos;, &apos;Company.data&apos;);
		/// Ext.namespace(&apos;Company.data&apos;); // equivalent and preferable to above syntax
		/// Company.Widget = function() { ... }
		/// Company.data.CustomStore = function(config) { ... }
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		/// <param name="namespaces"></param>
		/// <returns>The namespace object. (If multiple arguments are passed, this will be the last namespace created)</returns>
		[ScriptName("ns")]
		public static object Ns(params string[] namespaces)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Creates namespaces to be used for scoping variables and classes so that they are not global.
		/// Specifying the last node of a namespace implicitly creates all other nodes. Usage:
		/// 
		/// Ext.namespace(&apos;Company&apos;, &apos;Company.data&apos;);
		/// Ext.namespace(&apos;Company.data&apos;); // equivalent and preferable to above syntax
		/// Company.Widget = function() { ... }
		/// Company.data.CustomStore = function(config) { ... }
		/// </summary>
		/// <htmlSummary>
		/// Creates namespaces to be used for scoping variables and classes so that they are not global.
		/// Specifying the last node of a namespace implicitly creates all other nodes. Usage:
		/// &lt;pre&gt;&lt;code&gt;
		/// Ext.namespace(&apos;Company&apos;, &apos;Company.data&apos;);
		/// Ext.namespace(&apos;Company.data&apos;); // equivalent and preferable to above syntax
		/// Company.Widget = function() { ... }
		/// Company.data.CustomStore = function(config) { ... }
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\ext-core\src\core\Ext.js</definedin>
		/// <returns>The namespace object. (If multiple arguments are passed, this will be the last namespace created)</returns>
		[ScriptName("ns")]
		public static object Ns()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Shorthand for {@link Ext.util.JSON#decode}</summary>
		/// <definedin>src\ext-core\src\util\JSON.js</definedin>
		/// <param name="json">The JSON string</param>
		/// <param name="safe">Whether to return null or throw an exception if the JSON is invalid.</param>
		/// <returns>The resulting object</returns>
		[ScriptName("decode")]
		public static object Decode(string json, bool safe)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Shorthand for {@link Ext.util.JSON#decode}</summary>
		/// <definedin>src\ext-core\src\util\JSON.js</definedin>
		/// <param name="json">The JSON string</param>
		/// <returns>The resulting object</returns>
		[ScriptName("decode")]
		public static object Decode(string json)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Shorthand for {@link Ext.util.Functions#defer}</summary>
		/// <definedin>src\util\Function.js</definedin>
		/// <param name="fn">The function to defer.</param>
		/// <param name="millis">The number of milliseconds for the setTimeout call (if less than or equal to 0 the function is executed immediately)</param>
		/// <param name="scope">
		/// The scope (<c>&lt;b&gt;this&lt;/b&gt;</c> reference) in which the function is executed.
		/// &lt;b&gt;If omitted, defaults to the browser window.&lt;/b&gt;
		/// </param>
		/// <param name="args">Overrides arguments for the call. (Defaults to the arguments passed by the caller)</param>
		/// <param name="appendArgs">
		/// if True args are appended to call args instead of overriding,
		/// if a number the args are inserted at the specified position
		/// </param>
		/// <returns>The timeout id that can be used with clearTimeout</returns>
		[ScriptName("defer")]
		public static System.Number Defer(System.Delegate fn, System.Number millis, object scope, System.Array args, bool appendArgs)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Shorthand for {@link Ext.util.Functions#defer}</summary>
		/// <definedin>src\util\Function.js</definedin>
		/// <param name="fn">The function to defer.</param>
		/// <param name="millis">The number of milliseconds for the setTimeout call (if less than or equal to 0 the function is executed immediately)</param>
		/// <param name="scope">
		/// The scope (<c>&lt;b&gt;this&lt;/b&gt;</c> reference) in which the function is executed.
		/// &lt;b&gt;If omitted, defaults to the browser window.&lt;/b&gt;
		/// </param>
		/// <param name="args">Overrides arguments for the call. (Defaults to the arguments passed by the caller)</param>
		/// <param name="appendArgs">
		/// if True args are appended to call args instead of overriding,
		/// if a number the args are inserted at the specified position
		/// </param>
		/// <returns>The timeout id that can be used with clearTimeout</returns>
		[ScriptName("defer")]
		public static System.Number Defer(System.Delegate fn, System.Number millis, object scope, System.Array args, System.Number appendArgs)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Shorthand for {@link Ext.util.Functions#defer}</summary>
		/// <definedin>src\util\Function.js</definedin>
		/// <param name="fn">The function to defer.</param>
		/// <param name="millis">The number of milliseconds for the setTimeout call (if less than or equal to 0 the function is executed immediately)</param>
		/// <param name="scope">
		/// The scope (<c>&lt;b&gt;this&lt;/b&gt;</c> reference) in which the function is executed.
		/// &lt;b&gt;If omitted, defaults to the browser window.&lt;/b&gt;
		/// </param>
		/// <param name="args">Overrides arguments for the call. (Defaults to the arguments passed by the caller)</param>
		/// <returns>The timeout id that can be used with clearTimeout</returns>
		[ScriptName("defer")]
		public static System.Number Defer(System.Delegate fn, System.Number millis, object scope, System.Array args)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Shorthand for {@link Ext.util.Functions#defer}</summary>
		/// <definedin>src\util\Function.js</definedin>
		/// <param name="fn">The function to defer.</param>
		/// <param name="millis">The number of milliseconds for the setTimeout call (if less than or equal to 0 the function is executed immediately)</param>
		/// <param name="scope">
		/// The scope (<c>&lt;b&gt;this&lt;/b&gt;</c> reference) in which the function is executed.
		/// &lt;b&gt;If omitted, defaults to the browser window.&lt;/b&gt;
		/// </param>
		/// <returns>The timeout id that can be used with clearTimeout</returns>
		[ScriptName("defer")]
		public static System.Number Defer(System.Delegate fn, System.Number millis, object scope)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Shorthand for {@link Ext.util.Functions#defer}</summary>
		/// <definedin>src\util\Function.js</definedin>
		/// <param name="fn">The function to defer.</param>
		/// <param name="millis">The number of milliseconds for the setTimeout call (if less than or equal to 0 the function is executed immediately)</param>
		/// <returns>The timeout id that can be used with clearTimeout</returns>
		[ScriptName("defer")]
		public static System.Number Defer(System.Delegate fn, System.Number millis)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Shorthand for {@link Ext.util.Functions#createInterceptor}</summary>
		/// <definedin>src\util\Function.js</definedin>
		/// <param name="origFn">The original function.</param>
		/// <param name="newFn">The function to call before the original</param>
		/// <param name="scope">
		/// The scope (<c>&lt;b&gt;this&lt;/b&gt;</c> reference) in which the passed function is executed.
		/// &lt;b&gt;If omitted, defaults to the scope in which the original function is called or the browser window.&lt;/b&gt;
		/// </param>
		/// <returns>The new function</returns>
		[ScriptName("defer")]
		public static System.Function Defer(System.Delegate origFn, System.Delegate newFn, object scope)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Shorthand for {@link Ext.util.Functions#createInterceptor}</summary>
		/// <definedin>src\util\Function.js</definedin>
		/// <param name="origFn">The original function.</param>
		/// <param name="newFn">The function to call before the original</param>
		/// <returns>The new function</returns>
		[ScriptName("defer")]
		public static System.Function Defer(System.Delegate origFn, System.Delegate newFn)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Shorthand for {@link Ext.util.Functions#createDelegate}</summary>
		/// <definedin>src\util\Function.js</definedin>
		/// <param name="fn">The function to delegate.</param>
		/// <param name="scope">
		/// The scope (<c>&lt;b&gt;this&lt;/b&gt;</c> reference) in which the function is executed.
		/// &lt;b&gt;If omitted, defaults to the browser window.&lt;/b&gt;
		/// </param>
		/// <param name="args">Overrides arguments for the call. (Defaults to the arguments passed by the caller)</param>
		/// <param name="appendArgs">
		/// if True args are appended to call args instead of overriding,
		/// if a number the args are inserted at the specified position
		/// </param>
		/// <returns>The new function</returns>
		[ScriptName("defer")]
		public static System.Function Defer(System.Delegate fn, object scope, System.Array args, bool appendArgs)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Shorthand for {@link Ext.util.Functions#createDelegate}</summary>
		/// <definedin>src\util\Function.js</definedin>
		/// <param name="fn">The function to delegate.</param>
		/// <param name="scope">
		/// The scope (<c>&lt;b&gt;this&lt;/b&gt;</c> reference) in which the function is executed.
		/// &lt;b&gt;If omitted, defaults to the browser window.&lt;/b&gt;
		/// </param>
		/// <param name="args">Overrides arguments for the call. (Defaults to the arguments passed by the caller)</param>
		/// <param name="appendArgs">
		/// if True args are appended to call args instead of overriding,
		/// if a number the args are inserted at the specified position
		/// </param>
		/// <returns>The new function</returns>
		[ScriptName("defer")]
		public static System.Function Defer(System.Delegate fn, object scope, System.Array args, System.Number appendArgs)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Shorthand for {@link Ext.util.Functions#createDelegate}</summary>
		/// <definedin>src\util\Function.js</definedin>
		/// <param name="fn">The function to delegate.</param>
		/// <param name="scope">
		/// The scope (<c>&lt;b&gt;this&lt;/b&gt;</c> reference) in which the function is executed.
		/// &lt;b&gt;If omitted, defaults to the browser window.&lt;/b&gt;
		/// </param>
		/// <param name="args">Overrides arguments for the call. (Defaults to the arguments passed by the caller)</param>
		/// <returns>The new function</returns>
		[ScriptName("defer")]
		public static System.Function Defer(System.Delegate fn, object scope, System.Array args)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Shorthand for {@link Ext.util.Functions#createDelegate}</summary>
		/// <definedin>src\util\Function.js</definedin>
		/// <param name="fn">The function to delegate.</param>
		/// <param name="scope">
		/// The scope (<c>&lt;b&gt;this&lt;/b&gt;</c> reference) in which the function is executed.
		/// &lt;b&gt;If omitted, defaults to the browser window.&lt;/b&gt;
		/// </param>
		/// <returns>The new function</returns>
		[ScriptName("defer")]
		public static System.Function Defer(System.Delegate fn, object scope)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Shorthand for {@link Ext.util.Functions#createDelegate}</summary>
		/// <definedin>src\util\Function.js</definedin>
		/// <param name="fn">The function to delegate.</param>
		/// <returns>The new function</returns>
		[ScriptName("defer")]
		public static System.Function Defer(System.Delegate fn)
		{
			throw new System.Exception("Imported - not implemented");
		}
		#endregion
	}
}
